#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

typedef double ElemSet; /* 物品重量和价值均为实数 */
#define eps (1e-9)
typedef struct ObjNode *Objects;
struct ObjNode {
    int idx; /* 序号 */
    ElemSet w; /* 重量 */
    ElemSet v; /* 价值 */
};

int CmpValue(const void *a, const void *b) {
    /* 将物品s[]按原价非递增排序 */
    ElemSet va, vb;

    va = ((const struct ObjNode*)a)->v;
    vb = ((const struct ObjNode*)b)->v;
    return (va < vb) ? 1 : -1;
}

int CmpUnitValue(const void *a, const void *b) {
    /* 将物品s[]按单价非递增排序 */
    ElemSet va, vb;

    va = ((const struct ObjNode*)a)->v / ((const struct ObjNode*)a)->w;
    vb = ((const struct ObjNode*)b)->v / ((const struct ObjNode*)b)->w;
    return (va < vb) ? 1 : -1;
}

ElemSet Greedy(ElemSet W, Objects s, int *x, int n, int (*Cmp)(const void *a,
               const void *b)) {
    ElemSet f_value;
    int i;

    f_value = 0; /* 初始化优化函数f最优解的值 */
    memset(x, 0, n * sizeof(int)); /* 初始化解为 0 */
    /* 将物品s[]按Cmp给定规则非递增排序 */
    qsort(s, n, sizeof(struct ObjNode), Cmp);
    for (i = 0; i < n; i++) {
        if (W > eps) {
            /* 第i件物品的原始序列号为s[i].idx */
            if (W >= s[i].w) { /* 如果能完整放下 */
                x[s[i].idx] = 1; /* 第i件物品可以被完整收入背包 */
                f_value += s[i].v; /* 将s[i]收入背包 */
                W -= s[i].w; /* 更新背包剩余承重量 */
            } else { /* 放不下 */
                x[s[i].idx] = 0; /* 第i件物品被舍弃 */
            }
        } else {
            break; /* 背包已经装满 */
        }
    }
    return f_value;
}

/* 算法16-2：基于贪心策略的离散背包问题近似算法 KnapsackGreedyApproximation(W,s,x,n) */
ElemSet KnapsackGreedyApproximation(ElemSet W, Objects s, int *x, int n) {
    ElemSet ret, sum_v1, sum_v2;
    int *x1, *x2, i;

    x1 = (int *)malloc(sizeof(int) * n);
    x2 = (int *)malloc(sizeof(int) * n);
    sum_v1 = Greedy(W, s, x1, n, CmpValue);
    sum_v2 = Greedy(W, s, x2, n, CmpUnitValue);
    if (sum_v1 > sum_v2) {
        for (i = 0; i < n; i++) {
            x[i] = x1[i];
        }
        ret = sum_v1;
    } else {
        for (i = 0; i < n; i++) {
            x[i] = x2[i];
        }
        ret = sum_v2;
    }
    free(x1);
    free(x2);
    return ret;
}
/* 算法16-2 结束 */

int main(void) {
    Objects s;
    int *x;
    ElemSet W;
    int n, i;

    scanf("%d %lf", &n, &W);
    s = (Objects)malloc(sizeof(struct ObjNode) * n);
    x = (int *)malloc(sizeof(int) * n);
    for (i = 0; i < n; i++) {
        scanf("%lf", &s[i].w);
    }
    for (i = 0; i < n; i++) {
        scanf("%lf", &s[i].v);
        s[i].idx = i;
    }
    printf("%.2f\n", KnapsackGreedyApproximation(W, s, x, n));
    for (i = 0; i < n; i++) {
        printf("%d ", x[i]);
    }
    return 0;
}